package com.aurora.advanced;


import java.io.Serializable;

/**
 * 描述：elasticsearch实体类
 *
 * @author 浅夏的猫
 * @version 1.0.0
 * @date 2024-02-10 20:08:20
 */
public class ElasticsearchEntity implements Serializable {

    private static final long serialVersionUID = 1L;

    /**
     * 集群地址
     * */
    private String hosts;

    /**
     * 集群端口
     * */
    private Integer port;

    /**
     *执行计划
     * */
    private String scheme;

    /**
     * 文档类型，es7一般都是_doc
     * */
    private String type;

    /**
     * 索引前缀
     * */
    private String indexPrefix;

    /**
     * 内部批量处理器，刷新前最大缓存的操作数
     * */
    private Integer bulkFlushMaxActions=1;

    /**
     * 刷新前最大缓存的数据量（以兆字节为单位）
     * */
    private Integer bulkFlushMaxSizeMb=10;

    /**
     * 刷新的时间间隔（不论缓存操作的数量或大小如何）
     * */
    private Integer bulkFlushInterval=10000;

    /**
     * 是否启用批量写入的退避策略，当Elasticsearch 写入失败时，可以启用退避策略，以避免频繁的重试。
     * 此时，setBulkFlushBackoffDelay 和 setBulkFlushBackoffRetries 参数生效。
     * */
    private Boolean bulkFlushBackoff=false;

    /**
     * 设置批量写入的退避延迟时间,在发生写入失败后，等待指定的延迟时间后再进行重试
     * */
    private Integer bulkFlushBackoffDelay=10000;

    /**
     * 设置批量写入的最大重试次数,设置在写入失败后的最大重试次数。超过这个次数后，将不再重试
     * */
    private Integer bulkFlushBackoffRetries=3;

    /**
     * 设置与 Elasticsearch 集群建立连接的超时时间，单位为毫秒。在指定的时间内无法建立连接将会抛出连接超时异常
     * */
    private Integer connectTimeout=10000;

    /**
     * 设置与 Elasticsearch 连接的套接字超时时间，单位为毫秒。该参数定义了在建立连接后从服务器读取数据的超时时间。
     * */
    private Integer socketTimeout=10000;

    /**
     * 设置连接请求超时时间，单位为毫秒。该参数表示从连接池获取连接的超时时间。如果在指定的时间内无法获得连接，将会抛出连接请求超时异常。
     * */
    private Integer connectionRequestTimeout=10000;

    /**
     * 设置是否允许重定向。如果设置为true，则当遇到重定向响应时，客户端将跟随重定向并继续请求；如果设置为false，重定向响应将被视为错误。
     * */
    private Boolean redirectsEnabled=false;

    /**
     * 客户端允许的最大重定向次数
     * */
    private Integer maxRedirects=3;

    /**
     * 启用身份验证功能。通过设置该参数为true，可以提供用户名和密码进行身份验证，以连接到 Elasticsearch 集群。
     * */
    private Boolean authenticationEnabled=true;

    /**
     * 设置是否允许循环重定向。如果设置为true，则允许在重定向过程中发生循环重定向；如果设置为false，则在检测到循环重定向时，将会抛出异常。
     * */
    private Boolean circularRedirectsAllowed=false;

    /**
     * 设置是否启用内容压缩。如果设置为true，则允许客户端和 Elasticsearch 之间进行内容压缩，以减少数据传输量。
     * */
    private Boolean contentCompressionEnabled=false;

    /**
     * 设置是否启用 "Expect: continue" 机制。当设置为true时，在发送请求之前，客户端会发送一个请求头部，询问服务器是否接受请求的主体部分。
     * 如果服务器响应允许继续发送请求主体，则客户端会继续发送请求；如果服务器响应拒绝继续发送请求主体，则客户端会放弃该请求。
     * */
    private Boolean expectContinueEnabled=false;

    /**
     * 设置是否标准化 URI。如果设置为true，则客户端会尝试标准化请求 URI，以便消除多余和重复的斜杠等。
     * */
    private Boolean normalizeUri=false;

    /**
     * 用于设置 HTTP 请求的路径前缀。
     * 这个配置选项通常用于设置反向代理或者负载均衡器等中间件与 Elasticsearch 集群之间的连接
     * */
    private String pathPrefix;

    public String getHosts() {
        return hosts;
    }

    public void setHosts(String hosts) {
        this.hosts = hosts;
    }

    public Integer getPort() {
        return port;
    }

    public void setPort(Integer port) {
        this.port = port;
    }

    public String getScheme() {
        return scheme;
    }

    public void setScheme(String scheme) {
        this.scheme = scheme;
    }

    public String getType() {
        return type;
    }

    public void setType(String type) {
        this.type = type;
    }

    public String getIndexPrefix() {
        return indexPrefix;
    }

    public void setIndexPrefix(String indexPrefix) {
        this.indexPrefix = indexPrefix;
    }

    public Integer getBulkFlushMaxActions() {
        return bulkFlushMaxActions;
    }

    public void setBulkFlushMaxActions(Integer bulkFlushMaxActions) {
        this.bulkFlushMaxActions = bulkFlushMaxActions;
    }

    public Integer getBulkFlushMaxSizeMb() {
        return bulkFlushMaxSizeMb;
    }

    public void setBulkFlushMaxSizeMb(Integer bulkFlushMaxSizeMb) {
        this.bulkFlushMaxSizeMb = bulkFlushMaxSizeMb;
    }

    public Integer getBulkFlushInterval() {
        return bulkFlushInterval;
    }

    public void setBulkFlushInterval(Integer bulkFlushInterval) {
        this.bulkFlushInterval = bulkFlushInterval;
    }

    public Boolean getBulkFlushBackoff() {
        return bulkFlushBackoff;
    }

    public void setBulkFlushBackoff(Boolean bulkFlushBackoff) {
        this.bulkFlushBackoff = bulkFlushBackoff;
    }

    public Integer getBulkFlushBackoffDelay() {
        return bulkFlushBackoffDelay;
    }

    public void setBulkFlushBackoffDelay(Integer bulkFlushBackoffDelay) {
        this.bulkFlushBackoffDelay = bulkFlushBackoffDelay;
    }

    public Integer getBulkFlushBackoffRetries() {
        return bulkFlushBackoffRetries;
    }

    public void setBulkFlushBackoffRetries(Integer bulkFlushBackoffRetries) {
        this.bulkFlushBackoffRetries = bulkFlushBackoffRetries;
    }

    public Integer getConnectTimeout() {
        return connectTimeout;
    }

    public void setConnectTimeout(Integer connectTimeout) {
        this.connectTimeout = connectTimeout;
    }

    public Integer getSocketTimeout() {
        return socketTimeout;
    }

    public void setSocketTimeout(Integer socketTimeout) {
        this.socketTimeout = socketTimeout;
    }

    public Integer getConnectionRequestTimeout() {
        return connectionRequestTimeout;
    }

    public void setConnectionRequestTimeout(Integer connectionRequestTimeout) {
        this.connectionRequestTimeout = connectionRequestTimeout;
    }

    public Boolean getRedirectsEnabled() {
        return redirectsEnabled;
    }

    public void setRedirectsEnabled(Boolean redirectsEnabled) {
        this.redirectsEnabled = redirectsEnabled;
    }

    public Integer getMaxRedirects() {
        return maxRedirects;
    }

    public void setMaxRedirects(Integer maxRedirects) {
        this.maxRedirects = maxRedirects;
    }

    public Boolean getAuthenticationEnabled() {
        return authenticationEnabled;
    }

    public void setAuthenticationEnabled(Boolean authenticationEnabled) {
        this.authenticationEnabled = authenticationEnabled;
    }

    public Boolean getCircularRedirectsAllowed() {
        return circularRedirectsAllowed;
    }

    public void setCircularRedirectsAllowed(Boolean circularRedirectsAllowed) {
        this.circularRedirectsAllowed = circularRedirectsAllowed;
    }

    public Boolean getContentCompressionEnabled() {
        return contentCompressionEnabled;
    }

    public void setContentCompressionEnabled(Boolean contentCompressionEnabled) {
        this.contentCompressionEnabled = contentCompressionEnabled;
    }

    public Boolean getExpectContinueEnabled() {
        return expectContinueEnabled;
    }

    public void setExpectContinueEnabled(Boolean expectContinueEnabled) {
        this.expectContinueEnabled = expectContinueEnabled;
    }

    public Boolean getNormalizeUri() {
        return normalizeUri;
    }

    public void setNormalizeUri(Boolean normalizeUri) {
        this.normalizeUri = normalizeUri;
    }

    public String getPathPrefix() {
        return pathPrefix;
    }

    public void setPathPrefix(String pathPrefix) {
        this.pathPrefix = pathPrefix;
    }
}
